// ts 注解ts type script

// 类型推断 - 类型注解

/**
 * number
 * string
 * null
 * undefined
 * ...
 * any 任意类型
 * void 空
 * unknown 未知
 *
 */

// 基本类型 6

let num = '1'

const str: string = '123'

const boor: true = true

const n: null = null

const un: undefined = undefined

// const sym: ReturnType<typeof sym> = Symbol()

// 引用类型 3
const arr: number[] = []

arr.push(1)
// arr.push('null')
// arr.push(undefined)
// arr.push(() => {})

const brr: (number | string)[] = [1, '2', 3, '4']

// 元组
const crr: [string, string, boolean] = ['狂飙', '大明', true]

// 类型别名
type DrrType = [string, string, false]

const drr: DrrType = ['狂飙', '大明', false]

console.log('ar:', arr)

// 接口 interface
// 大写开头，type结尾，首字母大写的驼峰命名
// interface ObjType {
//   name: string
//   age: number
//   gender: number
//   address: () => string
// }

type AddressType = () => void

// key: value
interface ObjType {
  [key: string]: string | number | AddressType | boolean
}

// 对象
const obj: ObjType = {
  name: 'devin',
  age: 1,
  gender: 1,
  address: () => {
    console.log('上海市')
    // return '上海市'
  },
  sex: true,
}

// 函数注解
const func = (params: number) => {}

func(1)

// interface type

interface AutoType {
  page: number
  size: number
  name: string
  success: () => void
}

const auto = (params: AutoType) => {}

auto({
  page: 1,
  size: 5,
  name: 'devin',
  success: () => {},
})

type ParamsType = number[]

// 需求： 让这个数组的位置对调, 控制函数返回值
// => 箭头后面注解 就是注解函数返回值

// const reverseFunc = (params: ParamsType): ParamsType => {
//   return [params[1], params[0]]
// }

// reverseFunc([1, 2])

// 泛型⭐️
const reverseFunc = <T, U>(params: [T, U]): [U, T] => {
  return [params[1], params[0]]
}
// <类型传参数>
reverseFunc<number, number>([1, 2])

// ------------------------------------------------------------

type FrrType = {
  id: number
  name: string
}[]

const frr: FrrType = [
  { id: 1, name: '测试' },
  { id: 2, name: '测试' },
  { id: 3, name: '测试' },
  { id: 4, name: '测试' },
  { id: 5, name: '测试' },
  { id: 6, name: '测试' },
]

// 模拟一个 异步数据
// const MockData: () => Promise<FrrType> = () => {
//   return new Promise((resolve, reject) => {
//     setTimeout(() => {
//       resolve(frr)
//     }, 0)
//   })
// }

// MockData().then((res) => {
//   console.log('res:', res)
//   res.push({ id: 6, name: 'beijign' })
// })

// 模拟一个 异步数据 泛型
const MockData = (frr: FrrType) => {
  return new Promise<FrrType>((resolve, reject) => {
    setTimeout(() => {
      resolve(frr)
    }, 0)
  })
}

const autoFunc = async () => {
  const data = await MockData(frr)
  console.log('data:', data)
  data.push({ id: 5, name: 'city' })
}
